Swift - 整数和浮点数

Swift 中 ，数字分为整数 （例如 ：1 / 10 / 100 /1000 等） 和浮点数 （ 例如 ： 3.14 / 1.44 / 2.71 等）

整形 - Int & UInt

根据一个整形变量所占的内存空间 （8 / 16 / 32 /64-bit） 以及整数是否带有符号 （Unsinged） ， Swift 一共定义了8中不同类型的整数类型 :

  • Int (8 / 16 / 32 / 64)
  • UInt (8 / 16 / 32 / 64)

Int 的四个类型 分别表示 8 / 16 / 32 /64-bit 的有符号整数
UInt 的四个类型分别代表 8 / 16 / 32 /64-bit 的无符号整数

但在 Swift 中通常不会去指定具体的类型 ，Swift 编译器会根据目标编译平台 ，把 Int 或 UInt 转换成对应的整数。

在64位平台上 ，可以分别使用 min 和 max 方法，来查看在64位机器上整数类型可以表达的数值范围: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
Int.max    //9223372036854775807
Int.min    //-9223372036854775808

Int64.max  //9223372036854775807
Int64.min  //-9223372036854775807

Int32.max  //2147483647
Int32.min  //-2147483648

Int8.max   //127
Int8.min   //-128

Int16.max  //32767
Int16.min  //-32768

UInt.max   //9223372036854775807
UInt.min   //0

UInt64.max //9223372036854775807
UInt64.min //0

UInt32.max //4294967295
UInt32.min //0

UInt8.max  //255
UInt8.min  //0

整数的常用表达方式

在 Swift 里，我们可以用多种方式来表示一个整数。 包括使用 10 进制 、 16 进制 、 8 进制 、 2 进制: 

1
2
3
4
let fifteenInDecimal = 10       //10
let fiftennInHex = 0xff         //255
let fifteenInOctal = 0o17       //15
let fifteenInBinary = 0b0111    //7

以及可以在数字中使用分隔符 : 

1
2
3
4
5
6
7

let inDecimal = 10       //10
let inHex = 0xff         //255
let inOctal = 0o17       //15
let inBinary = 0b0111    //7

let million = 1_000_000  //1000000

除非我们所在硬件平台有特别明确的需求需要我们使用 UInt 来定义无符号整数 ， 否则我们应该尽可能使用 Int 来表达所有的整数类型 ， 哪怕我们确定一个整数一定是一个非负数。这会给我们减少很多不必要的类型转换的麻烦 。

浮点型 Float & Double

在 Swift 中 ，根据可以表达的精度范围，有两种不同的浮点类型 :

  • Float : 最多表达6位精度的浮点数
  • Double : 至少可以表达15位精度的浮点数
1
2
3
4

let floatValue : Float = 1/3    //0.3333333

let doubleValue : Double = 1/3  //0.3333333333333333

除了使用常规的十进制表达浮点数之外 , 我们还可以使用科学计数法 。 例如 ，表示浮点数 PI :

1
var PI = 0.314e1    //3.14

如果没有明确的需求，我们应该用Double来统一定义浮点数

和数字有关的 Type Inference

在 Swift 中 ，我们使用一个整数 ， 编译器会将它推导为 Int ， 使用一个浮点数 ，编译器会将它编译成 Double
使用 type(of:) 查看一个变量或者常量的类型

1
2
3
4
5
let four = 5
type(of: four)  //Int.Type

let zeroPointFour = 0.5
type(of: zeroPointFour) //Double.Type

在 Swift 中 ，可以对不同类型数字的字面量进行计算

1
2
3
4
5
6

let three = 2.8 + 0.2  //3
type(of: three)        //Double.Type

let four = 1 + 3       //4
type(of: four)         //Int.Type

但是在 Swift 中 ，不能把不同数字类型的变量直接进行算术运算

1
2
3
4
let zeroPointOne = 0.1;
let one = 1;

let onePointOne = zeroPointOne + one  //Binary operator '+' cannot be applied to operands of type 'Double' and 'Int'

当对变量进行算数运算的时候，所有变量的类型必须是相同的，如果变量类型不同，我们必须明确将其中的一些变量进行类型转换。像这样：

1
2
3
4
5

let zeroPointOne = 0.1;
let one = 1;

let onePointOne = zeroPointOne + Double(one)  //1.1

通过 Double(value) 重新初始化了一个 Double 类型的 one 。